##------------------------------------------------------------------------------
##
##	yasco-1.0 - Yet Another (Java)Script Obfuscator
##	Copyright (C) 2008-2011 Oliver Schieche <post@oliver-schieche.de>
##
##	Makes use of Yapp
##	Parse::Yapp - Copyright (c) 1998-2001, Francois Desarmenien, all right reserved.
##
##	$Id: MapString.pm 8 2011-07-07 08:42:03Z goresplatter1844@gmail.com $
##------------------------------------------------------------------------------
package Yasco::Filter::MapString;

use strict;
use vars qw[@ISA];

use MIME::Base64;
use Yasco::Filter::Result;
##------------------------------------------------------------------------------
BEGIN {
	require Yasco::Filter;
	@ISA = qw[Yasco::Filter];

	open FILE, '<', __FILE__ or die "Can't read ".__FILE__.": $!";
	my $code = [split /^__END__/m, do {local($/)=undef;<FILE>}]->[1];
	close FILE;

	$Yasco::__string_decode_stubs = {};

	$code =~ s/^\s+|\s+$//g;
	$code = [split /^==(\w+):\n/m, $code];
	shift @$code;
	$code = {@$code};
	map {$code->{$_} = [split /^~~~~~/m, $code->{$_}]} keys %$code;

	$Yasco::__string_decode_stubs = $code;
}
##------------------------------------------------------------------------------
sub tokens
	{
		'STRING'
	}
##------------------------------------------------------------------------------
sub new
	{
	    my $self  = shift;
	    my $options = shift;
	    $self = $self->SUPER::new($options);

		$Yasco::__string_list_name = '_osV'.int(99*rand)	unless defined($self->{'strings-hash'});
		$Yasco::__string_list_name = $self->{'strings-hash'}	if defined($self->{'strings-hash'});

		$self->{__ONCE_PREPEND} =
		$self->{__ONCE_APPEND} = '';
	    $self->{__STRINGS__} = {};
	    $self->{s_count} = 1;
	    $self->{encode} ||= 'rc4';

		INIT_ENCODER: for ($self->{encode}) {
			/oldstyle/ and do {
				$self->{ciphers} = [$self->{cipher} ? map{int} split('',$self->{cipher}) : map{int(rand()*16)}(1..10)];
				last INIT_ENCODER;
			};

			/rc4/ and do {
				$self->{rc4_KEY} ||= join '', map{chr(int(32 + rand() * 126))} 0..40;
				$self->{rc4_KEYLEN} = length $self->{rc4_KEY};

				$self->{rc4_S} = [0..255];
				$self->{rc4_K} = [map {ord} split / */, $self->{rc4_KEY}];
				$self->{rc4_I0} = 0;
				$self->{rc4_I1} = 0;

				for (my($i,$j) =(0,0); $i < 256; $i++)
					{
						$j = ($j + $self->{rc4_S}->[$i] + $self->{rc4_K}->[$i % $self->{rc4_KEYLEN}]) % 256;

						($self->{rc4_S}->[$i],$self->{rc4_S}->[$j]) =
						($self->{rc4_S}->[$j],$self->{rc4_S}->[$i]);
					}

				if ($self->{debug} || 0) {
					print STDERR "----- BEGIN KEY-STREAM -----\n";
					for (my $i = 0; $i < 256; $i++)
						{
							printf STDERR "%02X", $self->{rc4_S}->[$i];
							print STDERR "\n" if 0x1F == (0x1F & $i);
						}
					print STDERR "----- END KEY-STREAM -----\n";
				}

				last INIT_ENCODER;
			};

		}

	    $self
	}
##------------------------------------------------------------------------------
sub get_token()
	{
		my $self = shift;
		my ($o,$text) = @_;

		for ($text) {
			m{^//!\[ENCODE_NOT]} and do {
				$self->{__ONCE_IGNORE} = 1;
				return undef;
			};

			m{^//!\[ENCODE_APPEND=(.+)]} and do {
				$self->{__ONCE_APPEND} = $1;
				return undef;
			};

			m{^//!\[ENCODE_PREPEND=(.+)]} and do {
				$self->{__ONCE_PREPEND} = $1;
				return undef;
			};
		}

		undef
	}
##------------------------------------------------------------------------------
sub register_node()
	{
		my $self = shift;
		my ($o,$node) = @_;

		return if 'STRING' ne $$node->op;
		my $c = substr($$node->left, 0, 1);

		$$node->{left} = $c . $self->{__ONCE_PREPEND} . substr($$node->left,1,-1) . $self->{__ONCE_APPEND} . $c;
		$self->{__ONCE_PREPEND} =
		$self->{__ONCE_APPEND} = '';

		1
	}
##------------------------------------------------------------------------------
sub execute
	{
		my $self = shift;
		my ($o,$node) = @_;
		my $string = $node->left;

		if (exists $self->{__ONCE_IGNORE})
			{
				delete $self->{__ONCE_IGNORE};
				return;
			}

		my $c = substr $string, 0, 1;
		my $re = "\\\\($c)";
		$re = qr/$re/;

		$string =~ s/$re/$1/g;

		$o->{_OB_DATA}->{map_string} or do
			{
				throw Yasco::Filter::Result($string)
					if $o->option(qq{no_encode});

				my $method = '_encode_'.$self->{encode};

				throw Yasco::Filter::Result($self->$method($string)); #$self->_escape_encode($string));
			};

		$self->{__STRINGS__}->{$string} = $Yasco::__string_list_name.".s_".$self->{s_count}++
			unless defined($self->{__STRINGS__}->{$string});

		throw Yasco::Filter::Result($self->{__STRINGS__}->{$string})
	}
##------------------------------------------------------------------------------
sub post_process
	{
		my $self = shift;
		my $method = "_post_process_".$self->{encode};

		return $self->$method(@_);
	}
##------------------------------------------------------------------------------
sub _post_process_rc4
	{
		my $self = shift;
		my ($o,$code) = @_;
		my ($vl,$keys,$strings,%list);

		return unless %{$self->{__STRINGS__}};

		$strings = {map {$self->{__STRINGS__}->{$_} => $_} keys %{$self->{__STRINGS__}}};
		$keys = [sort {int(substr($a,index($a, '.')+3)) <=> int(substr($b,index($b, '.')+3))} keys %$strings];

		foreach my $k (@$keys)
			{
				my $v;

				##printf STDERR "Encoding \"%s\": %s\n", $k, $strings->{$k};

				$v = $self->_encode_rc4($strings->{$k});

				##printf STDERR "\t%s\n", join('', map {sprintf('%02X',ord($_))} split / */, $v);

				$v = encode_base64($v, '');

				##printf STDERR "\t%s\n", $v;

				$list{substr($k, index($k, '.') + 1)} = "'$v'";
			}

		$strings = [map {$_ .':'. $list{$_}} keys %list];

		$vl = (0+@$strings) >> 1;
		splice @$strings, $vl, 0, "s_0:'".encode_base64($self->{rc4_KEY}, '')."'", "s_".$self->{s_count}.":null";
		$strings = '{'.join(((5 & $o->option(qq{newlines})) ? ",\n" : ','), @$strings).'}';

		$vl = $Yasco::__string_decode_stubs->{rc4}->[$self->{debug} || 0];
		$vl =~ s/__STRING_LIST_NAME__/$Yasco::__string_list_name/;
		$vl =~ s/__STRINGS__/$strings/;

		$$code = $vl . ($o->option(qq{newlines}) ? "\n" : "") . $$code;
	}
##------------------------------------------------------------------------------
sub _post_process_oldstyle
	{
		my $self = shift;
		my ($o,$code) = @_;
		my $strings;

		return unless %{$self->{__STRINGS__}};
		my $vl = $self->_encode_and_transpose(join '', map{sprintf('%02x',$_)} @{$self->{ciphers}});

		$strings = "{s_0:'$vl',";
		$strings .= "\n" if (4 & $o->option(qq{newlines}));

		foreach my $k (keys %{$self->{__STRINGS__}})
			{
				my $v = $self->_encode_string($k);

				if ($Yasco::__string_list_name.'.s_0' eq $self->{__STRINGS__}->{$k})
					{
						die;
						chomp($v = encode_base64(substr($k,1,-1)));
						$v = $self->_transpose($v);
						$v = $self->_mask_base64($v);
						$strings .= "s_0:'".$v."'";
					}
				else
					{
						$strings .= substr($self->{__STRINGS__}->{$k},1+length $Yasco::__string_list_name).':'.$v;
					}
				$strings .= ",";
				$strings .= "\n" if (4 & $o->option(qq{newlines}));
			}

		$strings =~ s/[,\n]+$/}/;
		$vl = $Yasco::__string_decode_stubs->{oldstyle}->[$self->{debug} ? 0 : 1];
		$vl =~ s/__STRING_LIST_NAME__/$Yasco::__string_list_name/;
		$vl =~ s/__STRINGS__/$strings/;

		$$code = $vl . ($o->option(qq{newlines}) ? "\n" : "") . $$code;
	}
##------------------------------------------------------------------------------
sub _encode_rc4
	{
		my ($self, $string) = @_;
		my($result, $i, $j, $l) = ('');

		$string = substr($string, 1, -1);
		$result = '';

		while ($string =~ m{\\(?:
			([abcdeflnrt]) |
			x((?i:[a-f0-9]{2})) |
			u((?i:[a-f0-9]{4})) |
			(.)
		)}x)
			{
				CONVERT_ESCAPE: {
					defined($1) and do
						{
							$i = eval "\"\\$1\"";
							last CONVERT_ESCAPE;
						};

					defined($2) and do
						{
							$i = chr(hex($2));
							last CONVERT_ESCAPE;
						};

					defined($3) and do
						{
							$i = hex($3);
							die sprintf('Unsupported Unicode \\u%04X found in %s', $i, $_[1]) if 255 < $i;
							$i = chr($i);
							last CONVERT_ESCAPE;
						};

					defined($4) and do
						{
							$i = $4;
							last CONVERT_ESCAPE;
						};

					die 'WTF.';
				}

				$result .= "$`$i";
				$string = "$'";
			}

		$string = $result . $string;
		$string = [map {ord} split / */, $string];

		for ($result = '', $i = 0, $l = 0+@$string; $i < $l; $i++)
			{
				$self->{rc4_I0} = 0
					if 256 == ++$self->{rc4_I0};
				$self->{rc4_I1} += $self->{rc4_S}->[$self->{rc4_I0}];
				$self->{rc4_I1} -= 256
					while 255 < $self->{rc4_I1};
				($self->{rc4_S}->[$self->{rc4_I0}], $self->{rc4_S}->[$self->{rc4_I1}]) =
				($self->{rc4_S}->[$self->{rc4_I1}], $self->{rc4_S}->[$self->{rc4_I0}]);

				$j = ($self->{rc4_S}->[$self->{rc4_I0}] + $self->{rc4_S}->[$self->{rc4_I1}]) % 256;
				$result .= chr($string->[$i] ^ $self->{rc4_S}->[$j]);
			}

		return $result;
	}
##------------------------------------------------------------------------------
sub _encode_oldstyle
	{
		my ($self,$string) = @_;
		my ($res,$c,$n,$q) = ('',length($string)-2,0);

		$q = substr($string,0,1);
		$string = substr($string,1,-1);

		EENCODE: for (;$n < $c;$n++)
			{
				for (int(100*rand())) {
					my $c = substr($string,$n,1);
					$_ < 50 and do
						{
							$res .= sprintf('\\x%02x', ord($c));
							next EENCODE;
						};

					$res .= $c;
				}
			}

		$q.$res.$q
	}
##------------------------------------------------------------------------------
sub _encode_string
	{
	#	1. ROT13 entire string
	#	2. Transpose string
	#	3. Pick a new "cipher" each 6 characters
	#	4. XOR the 6 chars w/ cipher
	#	5. base64 encode the sucker
	#	6. mask base64 encoding

		my ($self,$string) = @_;
		my ($q) = substr($string,0,1);
		$string = substr($string,1,-1);
		return $q.$q unless length $string;

		eval("\$string =~ s{\\\\$1}{\\$1}g")
			while $string =~ m{\\([rntf])};

		$string =~ tr/a-zA-Z/n-za-mN-ZA-M/;	#rot13 rofl

	#	no can split via regex. newlines don't count as `.`
		my (@parts,$r);# = grep {length} split /(......)/, $string;
{no warnings;
		push(@parts,$r), $string = substr($string,6)
			while length($r = substr($string,0,6));
}
		my ($res) = ('');

		foreach my $part (@parts)
			{
				my ($cidx) = int(10*rand());
				my ($cipher) = ${$self->{ciphers}}[$cidx];
				$res .= hex($cidx);
				$res .= join '', map {chr(ord($_) ^ $cipher)} (split //, $part);
			}

		$res = $self->_encode_and_transpose($res);

		return $q . $res . $q;
	}
##------------------------------------------------------------------------------
sub _encode_and_transpose
	{
		my $self = shift;
		my $string = shift;

		($string = encode_base64($string)) =~ s/\r?\n//g;
#		$string = 'MACOEURESOUVREATAVOIXYOUBELONG2ME=======';
		$string = $self->_transpose($string);
		$string = $self->_mask_base64($string);

		$string

	}
##------------------------------------------------------------------------------
sub _mask_base64
	{
		my $p = shift;
		my $s = shift;
		$s =~ tr,+=/Ay3,Ay3.?&,;
		$s
	}
##------------------------------------------------------------------------------
sub _transpose
	{
		my $self = shift;
		my $string = shift;
		my $transposed = '';
		my $l = length $string;
		my $step = $l >> 2;

		die "BASE64 string has incorrect length" if 0 != ($l % 4);
#print " IN[$string]\n";
		$string = [split '', $string];
		for (my $n = 0; $step > $n; $n++)
			{
				$transposed .= $$string[$n+(0*$step)];
				$transposed .= $$string[$n+(1*$step)];
				$transposed .= $$string[$n+(2*$step)];
				$transposed .= $$string[$n+(3*$step)];
			}
#print "OUT[$transposed]\n";
		$transposed
	}
##------------------------------------------------------------------------------
1
__END__
==rc4:
var __STRING_LIST_NAME__=(function(_0) {
var _I,I,l=[],_l=[0xde,0xad,0xbe,0xef,0],_1=function(){var O=0,o='';while(++O<=26)o+=String.fromCharCode(64+O);o+=o.toLowerCase();O^=O;while(10>O)o+=O++;return o+'+/='}(),L='length',f='fromCharCode';for(;null!==(_I=_0['s_'+_l[4]]);_l[4]++){_I=_I.split('');I=[];while(_I[L]){for(_l[5]=0;4>_l[5];_l[5]++)_l[_l[5]]=_1.indexOf(_I.shift());I.push((_l[0]<<2)|(_l[1]>>4));if(64!=_l[2])I.push(((_l[1]&15)<<4)|(_l[2]>>2));if(64!=_l[3])I.push(((_l[2]&3)<<6)|_l[3])}if(l[L]){l[261]='';l[260]=I[L];l[258]&=0;for(;l[260]>l[258];l[258]++){if(256==++l[256])l[256]=0;l[257]+=l[l[256]];l[257]&=0xFF;l.push(l[l[256]]);l[l[256]]=l[l[257]];l[l[257]]=l.pop();l[261]+=String[f](I[l[258]]^l[(l[l[256]]+l[l[257]])%256])}_0['s_'+_l[4]]=l[261]}else{for(l[0]=0;256>l[0];l[++l[0]]=l[0]);l[0]^=l.pop();l.push(0,0,0,0,I[L]);for(;256>l[258];l[258]++){l[259]+=l[l[258]]+I[l[258]%l[260]];l[259]&=0xFF;l.push(l[l[258]]);l[l[258]]=l[l[259]];l[l[259]]=l.pop()}}}return _0
})(__STRINGS__);
~~~~~
// debugging; less temp vars
var __STRING_LIST_NAME__ = (function(vStrings) {

	var input, decoded, strNo = 0, S = [], enc = [0xde,0xad,0xbe,0xef],
		base64chars = function() {
			var a=0,res = '';
			while(++a<=26)
				res += String.fromCharCode(64+a);
			res += res.toLowerCase();
			a ^= a;
			while(10>a) res += a++;
			return res + '+/=';
		}();

	for (strNo = 0; null !== (input = vStrings['s_'+strNo]); strNo++)
		{
			//console.log("INPUT \""+input+"\"");
			input = input.split('');
			decoded = [];
			while (input.length)
				{
					for (enc[4] = 0; 4 > enc[4]; enc[4]++) enc[enc[4]] = base64chars.indexOf(input.shift());
					decoded.push((enc[0] << 2) | (enc[1]>>4));
					if(64 != enc[2]) decoded.push(((enc[1]&15)<<4)|(enc[2]>>2));
					if(64 != enc[3]) decoded.push(((enc[2]&3)<<6)|enc[3]);
				}

			if (0 == S.length)
				{
					for (S[0] = 0; 256 > S[0]; S[++S[0]]=S[0]);
					S[0] ^= S.pop();
					S.push(0,0,0,0,decoded.length);
					for (;256>S[0x102];S[0x102]++)
						{
							S[0x103] += S[S[0x102]] + decoded[S[0x102] % S[0x104]];
							S[0x103] &= 0xFF;
							S.push(S[S[0x102]]);
							S[S[0x102]] = S[S[0x103]];
							S[S[0x103]] = S.pop();
						}
				}
			else
				{
					S[0x105] = '';
					S[0x104] = decoded.length;
					S[0x102] &= 0;

					for (; S[0x104] > S[0x102]; S[0x102]++)
						{
							if (256 == ++S[0x100]) S[0x100] = 0;
							S[0x101] += S[S[0x100]];
							S[0x101] &= 0xFF;

							S.push(S[S[0x100]]);
							S[S[0x100]] = S[S[0x101]];
							S[S[0x101]] = S.pop();

							S[0x105] += String.fromCharCode(decoded[S[0x102]] ^ S[(S[S[0x100]] + S[S[0x101]]) % 256]);
						}

					vStrings['s_'+strNo] = S[0x105];
				}

		}

	return vStrings;

})(__STRINGS__);
~~~~~

// heavy debugging
var __STRING_LIST_NAME__ = (function(vStrings) {

	Number.prototype.toHex = function()
		{
			var n = 0+this;

			if (0 == n) return '00';
			var chars = '0123456789ABCDEF', res = '';
			while(0 != n)
				{
					res = chars.charAt(n&0xF) + res;
					n >>= 4;
				}
			return (1 == res.length ? '0' : '') + res;
		}

	Array.prototype.stringFromThis = function()
		{
			var n, res = '';
			for (n = 0; n < this.length; n++)
				res += String.fromCharCode(this[n]);
			return res;
		}

	Array.prototype.map = function(callback)
		{
			var n, res = new Array();

			for (n in this)
				res[n] = callback(this[n]);
			return res;
		}
	var input, decoded, strNo = 0, S = [], enc = [0xde,0xad,0xbe,0xef], i, j,
		base64chars = function() {
			var res = '', a;
			for (a = 0; a < 26; a++)
				res += String.fromCharCode(65+a);
			res += res.toLowerCase();
			for (a = 0; a < 10; a++)
				res += a;
			return res + '+/=';
		}();

	for (strNo = 0; null !== (input = vStrings['s_'+strNo]); strNo++)
		{
			console.log("INPUT \""+input+"\"");
			input = input.split('');
			decoded = [];
			while (input.length)
				{
					for (j = 0; j < 4; j++) enc[j] = base64chars.indexOf(input.shift());
					decoded.push((enc[0] << 2) | (enc[1]>>4));
					if(64 != enc[2]) decoded.push(((enc[1]&15)<<4)|(enc[2]>>2));
					if(64 != enc[3]) decoded.push(((enc[2]&3)<<6)|enc[3]);
				}

			if (0 == S.length)
				{
					console.log("KEY: " + decoded.stringFromThis());

					for (i = 0; 256 > i; S[i]=i++);
					S.push(0,0,0);
					for (i = S[0x102] = 0, l = decoded.length; 256 > i; i++)
						{
							S[0x102] += S[i] + decoded[i % l];
							S[0x102] &= 0xFF;
							S.push(S[i]);
							S[i] = S[S[0x102]];
							S[S[0x102]] = S.pop();
						}
					S.pop();

					console.log("KEYSTREAM:");
					for (var s = '', n = 0; n < S.length; n++)
						{
							s += S[n].toHex();
							if (0x1F == (n & 0x1F) || S.length - 1 == n) {
								console.log(s);
								s = '';
							}
						}
				}
			else
				{
					input = '';
					console.log("DECODED: \"" + decoded.stringFromThis() + "\"");
					console.log(decoded.map(function(e) {return new Number(0+e).toHex()}));

					for (i = 0, l = decoded.length; l > i; i++)
						{
							if (256 == ++S[0x100]) S[0x100] = 0;
							S[0x101] += S[S[0x100]];
							while (256 <= S[0x101])
								S[0x101] -= 256;

							S.push(S[S[0x100]]);
							S[S[0x100]] = S[S[0x101]];
							S[S[0x101]] = S.pop();

							j = (S[S[0x100]] + S[S[0x101]]) % 256;

							input += String.fromCharCode(decoded[i] ^ S[j]);
						}

					console.log("RESULT: \""+input+"\"");
					vStrings['s_'+strNo] = input;
				}

		}

	return vStrings;

})(__STRINGS__);

==oldstyle:
var __STRING_LIST_NAME__=(function(_l0) {
	var p = 0;
	var key_string = (function(){
		var a,
			s='',
			sf=function(wh) {
				return (1==wh?'toLowerCase':(2==wh?'fromCharCode':(3==wh?'charCodeAt':(4==wh?'indexOf':(5==wh?'charAt':'substr')))));
			};

		for (a = 0; 26 >= ++a; s+= String[sf(2)](64+a));	// (A..Z)
		s += s[sf(1)]();	// s += s.toLowerCase()  (a..z)

		a -= (1<<4);		// a = 26 - (16) => 10
		while (0<--a)
			s+=(0xa-a);		// (0..9)
		for (a = 0x3D2F2B; 0 != a; a >>= 8)
							//	0x3D = '='
							//	0x2F = '/'
							//	0x2B = '+'
			s += String[sf(2)](a&0xff);
		return s;
	})();	//	returns 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890+/=';
	var result = new Object;

	for (p in _l0)
		{
			var enc_start = (function(i0) {
				var _l0 = function(_i0,_i1,_i2) {
					/*
					 *	unmask base64
					 */
							while(-1!=--_i2)
								{
										var bit = _i2 & 0xf;
											cFind = _i2 & (0xff << (4+(bit<<3))),
											cRepl = 0xff & (_i1 >> (bit<<3));
										_i2 &= ~cFind;
										cFind >>=(4+(bit<<3));
										_i0 = _i0.replace(new RegExp((bit?'\\':'')+String.fromCharCode(cFind),'g'), String.fromCharCode(cRepl));
								}
							return _i0;
						};
					return _l0(_l0(i0,0x2B3D2F,0x4179333),0x417933,0x2E3F263);
				})(_l0[p]),
				string = '', pos = 0, l = enc_start.length >> 2;
			// transpose back
			for(k=0;4>k;k++)
				for(pos=0;l>pos;pos++)
					string += enc_start.charAt(k+4*pos);
			pos = 0;
			enc_start = string;
			string = '';
			while (enc_start.length) {
				var enc = new Array(),
					dec = new Array();
				for (k=0;4>k;k++) enc[k] = key_string.indexOf(enc_start.charAt(k));
				string += String.fromCharCode((enc[0]<<2)|(enc[1]>>4));
				if (64 != enc[2]) string += String.fromCharCode(((enc[1]&15)<<4)|(enc[2]>>2));
				if (64 != enc[3]) string += String.fromCharCode(((enc[2]&3)<<6)|enc[3]);
				enc_start = enc_start.substr(4);
			}
			while (parseInt(p.substr(2)) && pos < string.length)
				{
					var cipher = ((!!(pos%7))?cipher:(function() {nindex = parseInt(string.charAt(pos++),0x10);return parseInt(result.s_0.substr(nindex<<1,2),16);})());
					var c = string.charCodeAt(pos)^cipher;
					c = ((('A').charCodeAt(0) <= c && ('Z').charCodeAt(0) >= c)?(function(a){return (-13+a < ('A').charCodeAt(0)?(a+13):(a-13))})(c):c);
					c = ((('a').charCodeAt(0) <= c && ('z').charCodeAt(0) >= c)?(function(a){return (-13+a < ('a').charCodeAt(0)?(a+13):(a-13))})(c):c);
					enc_start += String.fromCharCode(c);
					pos++;
				}
			result[p] = (!!pos)?enc_start:string;
		}

	return result;
})(__STRINGS__);
~~~~~
var __STRING_LIST_NAME__=(function(_l0){
var l0=0,sf=function(wh){return(1==wh?'toLowerCase':(2==wh?'fromCharCode':(3==wh?'charCodeAt':(4==wh?'indexOf':(5==wh?'charAt':'substr')))));},l1=(function(){var a,s='';for(a=0;26>=++a;s+=String[sf(2)](64+a));s+=s[sf(1)]();a-=(1<<4);while(0<--a)s+=(0xa-a);for(a=0x3D2F2B;0!=a;a>>=8)s+=String[sf(2)](a&0xff);return s;})(),l2=new Object;for(l0 in _l0){var l3=(function(i0){var _l0=function(_i0,_i1,_i2){while(-1!=--_i2){var _i4=_i2&0xf,_i3=(0xff<<(4+(_i4<<3)))&_i2;_i2&=~_i3;_i3>>=(4+(_i4<<3));_i0=_i0.replace(new RegExp((_i4?'\\':'')+String[sf(2)](_i3),'g'),String[sf(2)](0xff&(_i1>>(_i4<<3))));}return _i0;};return _l0(_l0(i0,0x2B3D2F,0x4179333),0x417933,0x2E3F263);})(_l0[l0]),l4='',l5=0,l6,l7,l8,la,lb;la=l3.length>>2;for(lb=0;4>lb;++lb)for(l5=0;la>l5;l5++)l4+=l3[sf(5)](lb+(l5<<2));l5^=l5;l3=l4;l4='';while(l3.length){l6=new Array();for(k=0;4>k;k++)l6[k]=l1[sf(4)](l3[sf(5)](k));l4+=String[sf(2)]((l6[0]<<2)|(l6[1]>>4));if(64!=l6[2])l4+=String[sf(2)](((l6[1]&15)<<4)|(l6[2]>>2));if(64!=l6[3])l4+=String[sf(2)](((l6[2]&3)<<6)|l6[3]);l3=l3[sf(6)](4);}while(parseInt(l0[sf(6)](2))&&l5<l4.length){l7=((!!(l5%7))?l7:(function(){l9=parseInt(l4[sf(5)](l5++),0x10);return parseInt(l2.s_0[sf(6)](l9<<1,2),16);})());l8=l4[sf(3)](l5)^l7;l8=((('A')[sf(3)](0)<=l8&&('Z')[sf(3)](0)>=l8)?(function(a){return(-13+a<('A')[sf(3)](0)?(a+13):(a-13))})(l8):l8);l8=((('a')[sf(3)](0)<=l8&&('z')[sf(3)](0)>=l8)?(function(a){return(-13+a<('a')[sf(3)](0)?(a+13):(a-13))})(l8):l8);l3+=String[sf(2)](l8);l5++;}l2[l0]=(!!l5)?l3:l4;}return l2;
})(__STRINGS__);